class A {
  public name: string = 'hello';
}

export class B {
  public name: string = 'name';

  public constructor() {
    console.info('hello');
  }
}

export class C extends A {
  public constructor() {
    super();
    console.info('hello');
  }
}

// github
class A {}

class A {
  constructor() {
    doSomething();
  }
}

class A extends B {
  constructor() {}
}

class A extends B {
  constructor() {
    super('foo');
  }
}

class A extends B {
  constructor(foo, bar) {
    super(foo, bar, 1);
  }
}

class A extends B {
  constructor() {
    super();
    doSomething();
  }
}

class A extends B {
  constructor(...args) {
    super(...args);
    doSomething();
  }
}

class A {
  dummyMethod() {
    doSomething();
  }
}

class A extends B.C {
  constructor() {
    super(foo);
  }
}

class A extends B.C {
  constructor([a, b, c]) {
    super(...arguments);
  }
}

class A extends B.C {
  constructor(a = f()) {
    super(...arguments);
  }
}

class A extends B {
  constructor(a, b, c) {
    super(a, b);
  }
}

class A extends B {
  constructor(foo, bar) {
    super(foo);
  }
}

class A extends B {
  constructor(test) {
    super();
  }
}

class A extends B {
  constructor() {
    foo;
  }
}

class A extends B {
  constructor(foo, bar) {
    super(bar);
  }
}

// https://github.com/typescript-eslint/typescript-eslint/issues/15

declare class A {
  constructor();
}

class A {
  constructor();
}

abstract class A {
  constructor();
}

// https://github.com/typescript-eslint/typescript-eslint/issues/48

class A {
  constructor(private name: string) {}
}

class A {
  constructor(public name: string) {}
}

class A {
  constructor(protected name: string) {}
}

// https://github.com/typescript-eslint/typescript-eslint/pull/167#discussion_r252638401

class A {
  private constructor() {}
}

class A {
  protected constructor() {}
}

class A extends B {
  public constructor() {}
}

class A extends B {
  protected constructor(foo, bar) {
    super(bar);
  }
}

class A extends B {
  private constructor(foo, bar) {
    super(bar);
  }
}

class A extends B {
  public constructor(foo) {
    super(foo);
  }
}

class A extends B {
  public constructor(foo) {}
}

// type definition / overload

class A {
  constructor(foo);
}

class A extends Object {
  constructor(@Foo foo: string) {
    super(foo);
  }
}

class A extends Object {
  constructor(foo: string, @Bar() bar) {
    super(foo, bar);
  }
}

function doSomething() {
  throw new Error("Function not implemented.");
}